home *** CD-ROM | disk | FTP | other *** search
/ Champak 130 / Vol 130.iso / games / tom.swf / scripts / libs / kjc / KJC_enterframe.as next >
Encoding:
Text File  |  2011-04-12  |  14.2 KB  |  426 lines
  1. package libs.kjc
  2. {
  3.    import flash.display.MovieClip;
  4.    import flash.events.*;
  5.    
  6.    public class KJC_enterframe
  7.    {
  8.        
  9.       
  10.       public function KJC_enterframe()
  11.       {
  12.          super();
  13.       }
  14.       
  15.       private static function ELEmoveToValuex(param1:Event) : void
  16.       {
  17.          var _loc2_:* = param1.currentTarget;
  18.          var _loc3_:Number = Number(_loc2_.x);
  19.          _loc2_.x = _loc2_.Sx * (_loc2_.x - _loc2_.Tx) + _loc2_.Gx * (_loc2_.prevx - _loc2_.Tx) + _loc2_.Tx;
  20.          _loc2_.prevx = _loc3_;
  21.          ++_loc2_.TMx;
  22.          if(_loc2_.TMx == 50)
  23.          {
  24.             _loc2_.x = _loc2_.Tx;
  25.             _loc2_.removeEventListener(Event.ENTER_FRAME,ELEmoveToValuex);
  26.             finish(_loc2_.Fnx,_loc2_);
  27.             _loc2_.Fnx = null;
  28.          }
  29.       }
  30.       
  31.       public static function moveToFrame(param1:MovieClip, param2:int, param3:Function = null) : void
  32.       {
  33.          param1.removeEventListener(Event.ENTER_FRAME,EmoveToFrame);
  34.          param1.F = param2;
  35.          param1.D = param1.currentFrame < param2 ? 1 : (param1.currentFrame > param2 ? -1 : 0);
  36.          param1.Fn = param3;
  37.          param1.addEventListener(Event.ENTER_FRAME,EmoveToFrame);
  38.       }
  39.       
  40.       public static function moveToValue(param1:MovieClip, param2:int, param3:int, param4:String, param5:Function = null) : void
  41.       {
  42.          var _loc6_:Function = KJC_enterframe["EmoveToValue" + param4];
  43.          param1.removeEventListener(Event.ENTER_FRAME,_loc6_);
  44.          param1["T" + param4] = param2;
  45.          param1["S" + param4] = param3;
  46.          param1["Fn" + param4] = param5;
  47.          param1.addEventListener(Event.ENTER_FRAME,_loc6_);
  48.       }
  49.       
  50.       private static function EmoveToValuewidth(param1:Event) : void
  51.       {
  52.          var _loc2_:* = param1.currentTarget;
  53.          var _loc3_:Number = _loc2_.Twidth - _loc2_.width;
  54.          if(Math.abs(_loc3_) <= 1)
  55.          {
  56.             _loc2_.width = _loc2_.Twidth;
  57.             _loc2_.removeEventListener(Event.ENTER_FRAME,EmoveToValuewidth);
  58.             finish(_loc2_.Fnwidth,_loc2_);
  59.             _loc2_.Fnwidth = null;
  60.          }
  61.          else
  62.          {
  63.             _loc2_.width += _loc3_ / _loc2_.Swidth;
  64.          }
  65.       }
  66.       
  67.       private static function EmoveToValueheight(param1:Event) : void
  68.       {
  69.          var _loc2_:* = param1.currentTarget;
  70.          var _loc3_:Number = _loc2_.Theight - _loc2_.height;
  71.          if(Math.abs(_loc3_) <= 1)
  72.          {
  73.             _loc2_.height = _loc2_.Theight;
  74.             _loc2_.removeEventListener(Event.ENTER_FRAME,EmoveToValueheight);
  75.             finish(_loc2_.Fnheight,_loc2_);
  76.             _loc2_.Fnheight = null;
  77.          }
  78.          else
  79.          {
  80.             _loc2_.height += _loc3_ / _loc2_.Sheight;
  81.          }
  82.       }
  83.       
  84.       private static function EmoveToParabolic(param1:Event) : void
  85.       {
  86.          var _loc5_:Number = NaN;
  87.          var _loc6_:Function = null;
  88.          var _loc2_:* = param1.currentTarget;
  89.          var _loc3_:Number = _loc2_.TxP - _loc2_.x;
  90.          var _loc4_:Number = (_loc2_.ThP - _loc2_.y) / _loc2_.SyP;
  91.          if(Math.abs(_loc4_) <= 2 && _loc2_.DrP == 1)
  92.          {
  93.             _loc2_.DrP = -1;
  94.          }
  95.          if(_loc2_.DrP == -1)
  96.          {
  97.             if(_loc4_ < 0)
  98.             {
  99.                _loc5_ = _loc2_.TyP - _loc2_.y;
  100.             }
  101.             else
  102.             {
  103.                _loc5_ = _loc2_.y - _loc2_.TyP;
  104.             }
  105.          }
  106.          else
  107.          {
  108.             _loc5_ = 1;
  109.          }
  110.          if(Math.abs(_loc3_) <= _loc2_.SxP || _loc5_ < 0)
  111.          {
  112.             _loc2_.x = _loc2_.TxP;
  113.             _loc2_.removeEventListener(Event.ENTER_FRAME,EmoveToParabolic);
  114.             _loc6_ = _loc2_.FnP;
  115.             _loc2_.FnP = null;
  116.             _loc2_.FnPro = null;
  117.             finish(_loc6_,_loc2_);
  118.          }
  119.          else
  120.          {
  121.             if(_loc2_.FnPro != null)
  122.             {
  123.                _loc2_.FnPro(_loc2_);
  124.             }
  125.             _loc2_.x += _loc3_ / Math.abs(_loc3_) * _loc2_.SxP;
  126.             _loc2_.y += _loc2_.DrP * _loc4_;
  127.          }
  128.       }
  129.       
  130.       public static function moveToValueRV(param1:MovieClip, param2:int, param3:int, param4:int, param5:String, param6:Function = null) : void
  131.       {
  132.          var _loc7_:Function = KJC_enterframe["EmoveToValueRV" + param5];
  133.          param1.removeEventListener(Event.ENTER_FRAME,_loc7_);
  134.          param1["T" + param5] = param2;
  135.          param1["S" + param5] = param3;
  136.          param1["G" + param5] = param4;
  137.          if(param2 > param1[param5])
  138.          {
  139.             param1["DR" + param5] = 1;
  140.          }
  141.          else
  142.          {
  143.             param1["DR" + param5] = -1;
  144.          }
  145.          param1["M" + param5] = Math.abs(param2 - param1[param5]);
  146.          param1["Fn" + param5] = param6;
  147.          param1.addEventListener(Event.ENTER_FRAME,_loc7_);
  148.       }
  149.       
  150.       private static function EmoveToValueScale(param1:Event) : void
  151.       {
  152.          var _loc2_:* = param1.currentTarget;
  153.          var _loc3_:Number = _loc2_.Tscale - _loc2_.scaleX * 100;
  154.          if(Math.abs(_loc3_) <= 1)
  155.          {
  156.             _loc2_.scaleX = _loc2_.scaleY = _loc2_.Tscale / 100;
  157.             _loc2_.removeEventListener(Event.ENTER_FRAME,EmoveToValueScale);
  158.             finish(_loc2_.Fnscale,_loc2_);
  159.             _loc2_.Fnscale = null;
  160.          }
  161.          else
  162.          {
  163.             _loc2_.scaleX += _loc3_ / _loc2_.Sscale / 100;
  164.             _loc2_.scaleY = _loc2_.scaleX;
  165.          }
  166.       }
  167.       
  168.       private static function EmoveToValueRVheight(param1:Event) : void
  169.       {
  170.          var _loc2_:* = param1.currentTarget;
  171.          var _loc3_:Number = _loc2_.DRheight * _loc2_.Sheight;
  172.          _loc2_.Mheight -= Math.abs(_loc3_);
  173.          _loc2_.Sheight += _loc2_.Sheight / _loc2_.Gheight;
  174.          if(_loc2_.Mheight <= 0)
  175.          {
  176.             _loc2_.height = _loc2_.Theight;
  177.             _loc2_.removeEventListener(Event.ENTER_FRAME,EmoveToValueRVheight);
  178.             finish(_loc2_.Fnheight,_loc2_);
  179.             _loc2_.Fnheight = null;
  180.          }
  181.          else
  182.          {
  183.             _loc2_.height += _loc3_;
  184.          }
  185.       }
  186.       
  187.       public static function moveToValueScale(param1:MovieClip, param2:int, param3:int, param4:Function = null) : void
  188.       {
  189.          param1.removeEventListener(Event.ENTER_FRAME,EmoveToValueScale);
  190.          param1.Tscale = param2;
  191.          param1.Sscale = param3;
  192.          param1.Fnscale = param4;
  193.          param1.addEventListener(Event.ENTER_FRAME,EmoveToValueScale);
  194.       }
  195.       
  196.       private static function EmoveToValuerotation(param1:Event) : void
  197.       {
  198.          var _loc2_:* = param1.currentTarget;
  199.          var _loc3_:Number = _loc2_.Trotation - _loc2_.rotation;
  200.          if(Math.abs(_loc3_) <= 1)
  201.          {
  202.             _loc2_.rotation = _loc2_.Trotation;
  203.             _loc2_.removeEventListener(Event.ENTER_FRAME,EmoveToValuerotation);
  204.             finish(_loc2_.Fnrotation,_loc2_);
  205.             _loc2_.Fnrotation = null;
  206.          }
  207.          else
  208.          {
  209.             _loc2_.rotation += _loc3_ / _loc2_.Srotation;
  210.          }
  211.       }
  212.       
  213.       private static function EmoveToValuescaleX(param1:Event) : void
  214.       {
  215.          var _loc2_:* = param1.currentTarget;
  216.          var _loc3_:Number = _loc2_.TscaleX - _loc2_.scaleX * 100;
  217.          if(Math.abs(_loc3_) <= 1)
  218.          {
  219.             _loc2_.scaleX = _loc2_.TscaleX / 100;
  220.             _loc2_.removeEventListener(Event.ENTER_FRAME,EmoveToValuescaleX);
  221.             finish(_loc2_.FnscaleX,_loc2_);
  222.             _loc2_.FnscaleX = null;
  223.          }
  224.          else
  225.          {
  226.             _loc2_.scaleX += _loc3_ / _loc2_.SscaleX / 100;
  227.          }
  228.       }
  229.       
  230.       private static function EmoveToValuescaleY(param1:Event) : void
  231.       {
  232.          var _loc2_:* = param1.currentTarget;
  233.          var _loc3_:Number = _loc2_.TscaleY - _loc2_.scaleY * 100;
  234.          if(Math.abs(_loc3_) <= 1)
  235.          {
  236.             _loc2_.scaleY = _loc2_.TscaleY / 100;
  237.             _loc2_.removeEventListener(Event.ENTER_FRAME,EmoveToValuescaleY);
  238.             finish(_loc2_.FnscaleY,_loc2_);
  239.             _loc2_.FnscaleY = null;
  240.          }
  241.          else
  242.          {
  243.             _loc2_.scaleY += _loc3_ / _loc2_.SscaleY / 100;
  244.          }
  245.       }
  246.       
  247.       private static function EmoveToValueRVwidth(param1:Event) : void
  248.       {
  249.          var _loc2_:* = param1.currentTarget;
  250.          var _loc3_:Number = _loc2_.DRwidth * _loc2_.Swidth;
  251.          _loc2_.Mwidth -= Math.abs(_loc3_);
  252.          _loc2_.Swidth += _loc2_.Swidth / _loc2_.Gwidth;
  253.          if(_loc2_.Mwidth <= 0)
  254.          {
  255.             _loc2_.width = _loc2_.Twidth;
  256.             _loc2_.removeEventListener(Event.ENTER_FRAME,EmoveToValueRVwidth);
  257.             finish(_loc2_.Fnwidth,_loc2_);
  258.             _loc2_.Fnwidth = null;
  259.          }
  260.          else
  261.          {
  262.             _loc2_.width += _loc3_;
  263.          }
  264.       }
  265.       
  266.       private static function ELEmoveToValuey(param1:Event) : void
  267.       {
  268.          var _loc2_:* = param1.currentTarget;
  269.          var _loc3_:Number = Number(_loc2_.y);
  270.          _loc2_.y = _loc2_.Sy * (_loc2_.y - _loc2_.Ty) + _loc2_.Gy * (_loc2_.prevy - _loc2_.Ty) + _loc2_.Ty;
  271.          _loc2_.prevy = _loc3_;
  272.          ++_loc2_.TMy;
  273.          if(_loc2_.TMy == 20)
  274.          {
  275.             _loc2_.y = _loc2_.Ty;
  276.             _loc2_.removeEventListener(Event.ENTER_FRAME,ELEmoveToValuey);
  277.             finish(_loc2_.Fny,_loc2_);
  278.             _loc2_.Fny = null;
  279.          }
  280.       }
  281.       
  282.       private static function finish(param1:Function, param2:MovieClip) : void
  283.       {
  284.          if(param1 != null)
  285.          {
  286.             param1(param2);
  287.          }
  288.       }
  289.       
  290.       private static function EmoveToValueRVx(param1:Event) : void
  291.       {
  292.          var _loc2_:* = param1.currentTarget;
  293.          var _loc3_:Number = _loc2_.DRx * _loc2_.Sx;
  294.          _loc2_.Mx -= Math.abs(_loc3_);
  295.          _loc2_.Sx += _loc2_.Sx / _loc2_.Gx;
  296.          if(_loc2_.Mx <= 0)
  297.          {
  298.             _loc2_.x = _loc2_.Tx;
  299.             _loc2_.removeEventListener(Event.ENTER_FRAME,EmoveToValueRVx);
  300.             finish(_loc2_.Fnx,_loc2_);
  301.             _loc2_.Fnx = null;
  302.          }
  303.          else
  304.          {
  305.             _loc2_.x += _loc3_;
  306.          }
  307.       }
  308.       
  309.       private static function EmoveToValueRVy(param1:Event) : void
  310.       {
  311.          var _loc2_:* = param1.currentTarget;
  312.          var _loc3_:Number = _loc2_.DRy * _loc2_.Sy;
  313.          _loc2_.My -= Math.abs(_loc3_);
  314.          _loc2_.Sy += _loc2_.Sy / _loc2_.Gy;
  315.          if(_loc2_.My <= 0)
  316.          {
  317.             _loc2_.y = _loc2_.Ty;
  318.             _loc2_.removeEventListener(Event.ENTER_FRAME,EmoveToValueRVy);
  319.             finish(_loc2_.Fny,_loc2_);
  320.             _loc2_.Fny = null;
  321.          }
  322.          else
  323.          {
  324.             _loc2_.y += _loc3_;
  325.          }
  326.       }
  327.       
  328.       public static function ELmoveToValue(param1:MovieClip, param2:int, param3:Number, param4:Number, param5:String, param6:Function = null) : void
  329.       {
  330.          var _loc7_:Function = KJC_enterframe["ELEmoveToValue" + param5];
  331.          param1.removeEventListener(Event.ENTER_FRAME,_loc7_);
  332.          param1["TM" + param5] = 0;
  333.          param1["T" + param5] = param2;
  334.          param1["S" + param5] = param3;
  335.          param1["G" + param5] = param4;
  336.          param1["prev" + param5] = param1[param5];
  337.          param1["Fn" + param5] = param6;
  338.          param1.addEventListener(Event.ENTER_FRAME,_loc7_);
  339.       }
  340.       
  341.       private static function EmoveToValuex(param1:Event) : void
  342.       {
  343.          var _loc2_:* = param1.currentTarget;
  344.          var _loc3_:Number = _loc2_.Tx - _loc2_.x;
  345.          if(Math.abs(_loc3_) <= 1)
  346.          {
  347.             _loc2_.x = _loc2_.Tx;
  348.             _loc2_.removeEventListener(Event.ENTER_FRAME,EmoveToValuex);
  349.             finish(_loc2_.Fnx,_loc2_);
  350.             _loc2_.Fnx = null;
  351.          }
  352.          else
  353.          {
  354.             _loc2_.x += _loc3_ / _loc2_.Sx;
  355.          }
  356.       }
  357.       
  358.       private static function EmoveToValuey(param1:Event) : void
  359.       {
  360.          var _loc2_:* = param1.currentTarget;
  361.          var _loc3_:Number = _loc2_.Ty - _loc2_.y;
  362.          if(Math.abs(_loc3_) <= 1)
  363.          {
  364.             _loc2_.y = _loc2_.Ty;
  365.             _loc2_.removeEventListener(Event.ENTER_FRAME,EmoveToValuey);
  366.             finish(_loc2_.Fny,_loc2_);
  367.             _loc2_.Fny = null;
  368.          }
  369.          else
  370.          {
  371.             _loc2_.y += _loc3_ / _loc2_.Sy;
  372.          }
  373.       }
  374.       
  375.       public static function moveToParabolic(param1:MovieClip, param2:int, param3:int, param4:Number, param5:Number, param6:int, param7:Function = null, param8:* = null) : void
  376.       {
  377.          param1.removeEventListener(Event.ENTER_FRAME,EmoveToParabolic);
  378.          param1.TxP = param2;
  379.          param1.ThP = param3;
  380.          param1.TyP = param6;
  381.          param1.SxP = param4;
  382.          param1.SyP = param5;
  383.          param1.DrP = 1;
  384.          param1.FnP = param7;
  385.          param1.FnPro = param8;
  386.          param1.addEventListener(Event.ENTER_FRAME,EmoveToParabolic);
  387.       }
  388.       
  389.       private static function EmoveToFrame(param1:Event) : void
  390.       {
  391.          var _loc3_:Function = null;
  392.          var _loc2_:* = param1.currentTarget;
  393.          _loc2_.gotoAndStop(_loc2_.currentFrame + _loc2_.D);
  394.          if(_loc2_.currentFrame == _loc2_.F)
  395.          {
  396.             _loc2_.removeEventListener(Event.ENTER_FRAME,EmoveToFrame);
  397.             _loc3_ = _loc2_.Fn;
  398.             _loc2_.Fn = null;
  399.             finish(_loc3_,_loc2_);
  400.          }
  401.       }
  402.       
  403.       private static function EmoveToValuealpha(param1:Event) : void
  404.       {
  405.          var _loc2_:* = param1.currentTarget;
  406.          _loc2_.visible = true;
  407.          var _loc3_:Number = _loc2_.Talpha - _loc2_.alpha * 100;
  408.          if(Math.abs(_loc3_) <= 10)
  409.          {
  410.             if(_loc2_.Talpha == 0)
  411.             {
  412.                _loc2_.visible = false;
  413.             }
  414.             _loc2_.removeEventListener(Event.ENTER_FRAME,EmoveToValuealpha);
  415.             _loc2_.alpha = _loc2_.Talpha / 100;
  416.             finish(_loc2_.Fnalpha,_loc2_);
  417.             _loc2_.Fnalpha = null;
  418.          }
  419.          else
  420.          {
  421.             _loc2_.alpha += _loc3_ / _loc2_.Salpha / 100;
  422.          }
  423.       }
  424.    }
  425. }
  426.